package edu.pe.cayetano.model.bo;

import java.util.ArrayList;

import org.apache.commons.beanutils.DynaBean;
import org.apache.xerces.impl.dv.util.Base64;

import ws.synopsis.frmwrk.common.BResult;
import edu.pe.cayetano.dao.ModuloDAO;
import edu.pe.cayetano.dao.OpcionDAO;
import edu.pe.cayetano.dao.OperacionesComunesDAO;
import edu.pe.cayetano.dao.UsuarioDAO;
import edu.pe.cayetano.framework.BusinessException;
import edu.pe.cayetano.framework.Configuration;
import edu.pe.cayetano.model.to.AlumnoTO;
import edu.pe.cayetano.model.to.MedicoDocenteTO;
import edu.pe.cayetano.model.to.OpcionTO;
import edu.pe.cayetano.model.to.UsuarioTO;
import edu.pe.cayetano.seccd.constantes.ConstantesMensajes;
import edu.pe.cayetano.seccd.constantes.ConstantesMensajesTrace;
import edu.pe.cayetano.seccd.constantes.ConstantesSECCD;
import edu.pe.cayetano.util.UtilTipoDato;
import edu.pe.cayetano.util.Utilitario;
import edu.pe.cayetano.wsseguridad.WSSeguridadProxy;
import edu.pe.cayetano.wsseguridad.to.WSCabeceraSeguridadTO;
import edu.pe.cayetano.wsseguridad.to.WSRespuestaSeguridadTO;
import edu.pe.cayetano.wsusuario.WSUsuarioProxy;
import edu.pe.cayetano.wsusuario.to.WSCabeceraUsuarioTO;
import edu.pe.cayetano.wsusuario.to.WSDatosListaUsuarioTO;
import edu.pe.cayetano.wsusuario.to.WSRespuestaListaUsuarioTO;
import edu.pe.cayetano.wsusuario.to.WSRespuestaUsuarioTO;
import edu.pe.cayetano.wsusuario.to.WSUsuarioTO;

public class UsuarioBO  extends BaseBO{

	private	String		schema			= Configuration.getSchemaDB();
	
	public StringBuffer estableceQuery(DynaBean dyna){
		StringBuffer 	query 		= new StringBuffer();
		String 			campo		= Utilitario.getPropertyDynaBean(dyna, "optCampo");
		String 			criterio	= Utilitario.getPropertyDynaBean(dyna, "criterio");
		String 			operacion	= Utilitario.getPropertyDynaBean(dyna, "operacion");
		String 			codigo		= Utilitario.getPropertyDynaBean(dyna, "codigo"); 

		if(ConstantesSECCD.OPERACION_BUSQUEDA.equalsIgnoreCase(operacion)&&operacion!=null){
			if(ConstantesSECCD.CRITERIO_TODOS.equalsIgnoreCase(campo)&&campo!=null){
				query.append(" SELECT A.COD_USUARIO AS COD_USUARIO,APE_PATERNO,APE_MATERNO,A.NOMBRE AS NOMBRE,USERNAME,");
				query.append(" PASSWORD,E.NOMBRE AS ESTADO,C.NOMBRE AS PERFIL");     
				query.append(" FROM "+schema+"USUARIO A ");
				query.append(" INNER JOIN "+schema+"PERFIL C");
				query.append(" ON A.COD_PERFIL=C.COD_PERFIL");
				query.append(" INNER JOIN "+schema+"ESTADO E");
				query.append(" ON E.ESTADO_ID=A.ESTADO_ID");
			}
			else{
				query.append(" SELECT A.COD_USUARIO AS COD_USUARIO,APE_PATERNO,APE_MATERNO,A.NOMBRE AS NOMBRE,USERNAME,");
				query.append(" PASSWORD,E.NOMBRE AS ESTADO,C.NOMBRE AS PERFIL");        
				query.append(" FROM "+schema+"USUARIO A ");
				query.append(" INNER JOIN "+schema+"PERFIL C");
				query.append(" ON A.COD_PERFIL=C.COD_PERFIL");
				query.append(" INNER JOIN "+schema+"ESTADO E");
				query.append(" ON E.ESTADO_ID=A.ESTADO_ID");
				query.append(" WHERE UPPER("+campo+") LIKE '%"+criterio.toUpperCase()+"%'");
			}
		}
		if(ConstantesSECCD.OPERACION_LISTADO.equalsIgnoreCase(operacion)&&operacion!=null){
				query.append(" SELECT A.COD_USUARIO AS COD_USUARIO,APE_PATERNO,APE_MATERNO,A.NOMBRE AS NOMBRE,USERNAME,");
				query.append(" PASSWORD,E.NOMBRE AS ESTADO,C.NOMBRE AS PERFIL");       
				query.append(" FROM "+schema+"USUARIO A ");
				query.append(" INNER JOIN "+schema+"PERFIL C");
				query.append(" ON A.COD_PERFIL=C.COD_PERFIL");
				query.append(" INNER JOIN "+schema+"ESTADO E");
				query.append(" ON E.ESTADO_ID=A.ESTADO_ID");
		}
		if(ConstantesSECCD.OPERACION_BUSQUEDA_ESPECIFICA.equalsIgnoreCase(operacion)){
			query.append(" SELECT A.COD_USUARIO AS COD_USUARIO,APE_PATERNO,APE_MATERNO,A.NOMBRE AS NOMBRE,USERNAME,");
			query.append(" PASSWORD,E.NOMBRE AS ESTADO,C.NOMBRE AS PERFIL");    
			query.append(" FROM "+schema+"USUARIO A ");
			query.append(" INNER JOIN "+schema+"PERFIL C");
			query.append(" ON A.COD_PERFIL=C.COD_PERFIL");
			query.append(" WHERE A.COD_USUARIO="+codigo);
		}
		System.out.println("[SECCD][UsuarioBO][estableceQuery] query:"+query.toString());
		return query;
	}
		
	/**
	 * Metodo que cambia la clave de un usuario
	 * */
	public BResult cambiaClave(String codigoUsuario,String password) throws BusinessException{
		BResult 				retSalida		= new BResult();
		WSRespuestaSeguridadTO	respuesta		= new WSRespuestaSeguridadTO();
		WSSeguridadProxy 		wsSeguridad		= new WSSeguridadProxy();
		WSCabeceraSeguridadTO	cabeceraTO		= new WSCabeceraSeguridadTO();
		
		try {
			byte[] encoded =  Base64.encode(password.getBytes());
			String password_encoded = new String(encoded);
		
			cabeceraTO.setCod_usuario(codigoUsuario);
			cabeceraTO.setPassword(password_encoded);
			respuesta = wsSeguridad.cambiaPassword(cabeceraTO);
			if(respuesta.getCodigoRespuesta().equalsIgnoreCase("0")){
				retSalida.setCode(ConstantesSECCD.EXITO_RET);
			}else{
				retSalida.setCode(ConstantesSECCD.ERROR_RET);
			}
		} catch (Exception e) {
			System.out.println("[SECCD][UsuarioBO][cambiaClave] error generado por:"+e.getMessage());
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
		}
		return retSalida;
	}
	
	/**
	 * Metodo que recupera el listado de usuarios
	 * */
	public BResult listarUsuario() throws BusinessException{
		BResult 				retTemp			= new BResult();
		BResult 				retSalida		= new BResult();
		try{
			System.out.println("[SECCD][UsuarioBO][listarUsuarios] inicio de metodo");
			retTemp = getListaUsuarioxWebService();
			System.out.println("[SECCD][UsuarioBO][listarUsuarios] retSalida.getCode():<"+retTemp.getCode()+">");
			if(retTemp.getCode()==0 && retTemp.getObject()!=null){
				WSDatosListaUsuarioTO  listaUsuario = (WSDatosListaUsuarioTO)retTemp.getObject();
				WSUsuarioTO [] arregloUsuario = listaUsuario.getListaUsuario();
				System.out.println("[SECCD][UsuarioBO][listarUsuarios] arregloUsuario.length():<"+arregloUsuario.length+">");
				ArrayList	listaSalida = new ArrayList();
				for(int i=0;i<arregloUsuario.length;i++){
					listaSalida.add(arregloUsuario[i]);
				}
				System.out.println("[SECCD][UsuarioBO][listarUsuarios] listaUsuario.size():<"+listaSalida.size()+">");
				retSalida.setCode(0);
				retSalida.setObject(listaSalida);
			}else{
				retSalida.setCode(ConstantesSECCD.ERROR_RET);
			}
		}catch(Exception e){
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
			retSalida.setMessage("[SECCD][UsuarioBO][listarUsuario] exception generado por:"+e.getMessage());
		}
		return retSalida;
	}

	/**
	 * Metodo para buscar un usuario
	 * */
	public BResult buscarUsuario(DynaBean dyna) throws BusinessException{
		BResult 				retSalida		= null;
		OperacionesComunesDAO				operacionesDAO		= null;
		try{
			System.out.println("[SECCD][UsuarioBO][buscarUsuario] inicio de metodo");
			conectar();
			operacionesDAO	 	= new OperacionesComunesDAO(conn);
			StringBuffer query = estableceQuery(dyna);
			retSalida 	= operacionesDAO.listado(query);
		}catch(Exception e){
			retSalida = new BResult();
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
			retSalida.setMessage("[SECCD][UsuarioBO][buscarUsuario] exception generado por:"+e.getMessage());
		}finally{
			try{
				desconectar();
			}catch(Exception e){
				retSalida = new BResult();
				retSalida.setCode(ConstantesSECCD.ERROR_RET);
				retSalida.setMessage("[SECCD][UsuarioBO][buscarUsuario] exception en el finally generado por:"+e.getMessage());
			}
		}
		return retSalida;
	}
	


	public BResult grabaEditaUsuario(DynaBean dyna) throws BusinessException{
		BResult 				retSalida		= null;
		UsuarioDAO				usuarioDAO		= null;
		try{
			conectar();
			usuarioDAO	 	= new UsuarioDAO(conn);
			retSalida 		= usuarioDAO.grabaEditaUsuario(dyna);
		}catch(Exception e){
			retSalida = new BResult();
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
			retSalida.setMessage("[UsuarioBO] error en metodo grabaEditaUsuario generado por:"+e.getMessage());
		}finally{
			try{
				desconectar();
			}catch(Exception e){
				retSalida = new BResult();
				retSalida.setCode(ConstantesSECCD.ERROR_RET);
				retSalida.setMessage("[UsuarioBO] error en metodo grabaEditaUsuario generador po:"+e.getMessage());
			}
		}
		return retSalida;
	}
	
	public BResult grabaInsertaUsuario(DynaBean dyna) throws BusinessException{
		BResult 				retSalida		= null;
		UsuarioDAO				usuarioDAO		= null;
		try{
			conectar();
			usuarioDAO	 	= new UsuarioDAO(conn);
			int codigo		= usuarioDAO.obtieneUltimoCodigoUsuario();
			retSalida 		= usuarioDAO.grabaInsertaUsuario(dyna,codigo);
		}catch(Exception e){
			retSalida = new BResult();
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
			retSalida.setMessage("[UsuarioBO] error en metodo grabaInsertaUsuario generado por:"+e.getMessage());
		}finally{
			try{
				desconectar();
			}catch(Exception e){
				retSalida = new BResult();
				retSalida.setCode(ConstantesSECCD.ERROR_RET);
				retSalida.setMessage("[UsuarioBO] error en metodo grabaInsertaUsuario generador po:"+e.getMessage());
			}
		}
		return retSalida;
	}
	
	/**
	 * Busca los datos de un usuario especifico
	 * */
	public BResult buscarUsuarioEspecifico(DynaBean dyna) throws BusinessException{
		BResult 				retSalida		= null;
		UsuarioDAO				usuarioDAO		= null;
		try{
			conectar();
			usuarioDAO	 	= new UsuarioDAO(conn);
			retSalida 		= usuarioDAO.retornaUsuario(Utilitario.getPropertyDynaBean(dyna, "codigo"));
		}catch(Exception e){
			retSalida = new BResult();
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
			retSalida.setMessage("[UsuarioBO] error en metodo buscarUsuarioEspecifico:"+e.getMessage());
		}finally{
			try{
				desconectar();
			}catch(Exception e){
				retSalida = new BResult();
				retSalida.setCode(ConstantesSECCD.ERROR_RET);
				retSalida.setMessage("[UsuarioBO] error en metodo buscarUsuarioEspecifico:"+e.getMessage());
			}
		}
		return retSalida;
	}

	/**
	 * Valida el login de un usario mediante el empleo de un web service
	 * */
	public BResult	validaUsuarioxWebService(String username,String password){

		BResult 				retSalida		= new BResult();
		WSRespuestaUsuarioTO	respuesta		= new WSRespuestaUsuarioTO();
		WSUsuarioProxy 			wsUsuario		= new WSUsuarioProxy();
		WSCabeceraUsuarioTO		cabeceraTO		= new WSCabeceraUsuarioTO();
		
		try {
			byte[] encoded =  Base64.encode(password.getBytes());
			String password_encoded = new String(encoded);
		
			cabeceraTO.setUsername(username);
			cabeceraTO.setPassword(password_encoded);
			
			System.out.println("[SECCD][UsuarioBO][validaUsuarioxWebService] username:<"+username+">");
			System.out.println("[SECCD][UsuarioBO][validaUsuarioxWebService] password:<"+password_encoded+">");
							
			respuesta = wsUsuario.getUsuario(cabeceraTO);
			retSalida = validaCodigoRespuestaValidaUsuario(respuesta);
			
		} catch (Exception e) {
			System.out.println("[SECCD][UsuarioBO][validaUsuarioxWebService] error generado por:"+e.getMessage());
		}
		return retSalida;
	}
	
	/**
	 * Valida el login de un usario mediante el empleo de un web service
	 * */
	public BResult	getListaUsuarioxWebService(){

		BResult 					retSalida		= new BResult();
		WSRespuestaListaUsuarioTO	respuesta		= new WSRespuestaListaUsuarioTO();
		WSUsuarioProxy 				wsUsuario		= new WSUsuarioProxy();		
		try {
			respuesta = wsUsuario.getListaUsuario();
			System.out.println("[SECCD][UsuarioBO][getListaUsuarioxWebService] codigo de respuesta:<"+respuesta.getCodigoRespuesta()+">");
			if("0".equalsIgnoreCase(respuesta.getCodigoRespuesta())){
				retSalida.setCode(0);
				retSalida.setObject(respuesta.getDatos());
			}else{
				retSalida.setCode(-1);
			}
		} catch (Exception e) {
			System.out.println("[SECCD][UsuarioBO][getListaUsuarioxWebService] exception generado por:"+e.getMessage());
		}
		return retSalida;
	}
	
	/**
	 * Valida el login de un usario mediante el empleo de un web service
	 * */
	public BResult	getBuscaUsuarioxWebService(WSCabeceraUsuarioTO cabeceraTO){

		BResult 					retSalida		= new BResult();
		WSRespuestaListaUsuarioTO	respuesta		= new WSRespuestaListaUsuarioTO();
		WSUsuarioProxy 				wsUsuario		= new WSUsuarioProxy();		
		try {
			respuesta = wsUsuario.findUsuario(cabeceraTO);
			System.out.println("[SECCD][UsuarioBO][getBuscaUsuarioxWebService] codigo de respuesta:<"+respuesta.getCodigoRespuesta()+">");
			if("0".equalsIgnoreCase(respuesta.getCodigoRespuesta())){
				retSalida.setCode(0);
				retSalida.setObject(respuesta.getDatos());
			}else{
				retSalida.setCode(-1);
			}
		} catch (Exception e) {
			System.out.println("[SECCD][UsuarioBO][getBuscaUsuarioxWebService] exception generado por:"+e.getMessage());
		}
		return retSalida;
	}
	
	
	/**
	 * Metodo para buscar un usuario por web service
	 * */
	public BResult buscarUsuarioxWebService(DynaBean dyna) throws BusinessException{
		BResult 					retSalida		= new BResult();
		WSUsuarioProxy 				wsUsuario		= new WSUsuarioProxy();
		WSCabeceraUsuarioTO			cabeceraTO		= new WSCabeceraUsuarioTO();
		try{
			System.out.println("[SECCD][UsuarioBO][buscarUsuarioxWebSevice] inicio de metodo");
			cabeceraTO.setCampo(Utilitario.getPropertyDynaBean(dyna, "optCampo"));
			cabeceraTO.setCriterio(Utilitario.getPropertyDynaBean(dyna, "criterio"));
			BResult respuesta = getBuscaUsuarioxWebService(cabeceraTO);
			System.out.println("[SECCD][UsuarioBO][buscarUsuarioxWebService] codigo de respuesta:<"+respuesta.getCode()+">");
			if(respuesta.getCode()==0){
				WSDatosListaUsuarioTO  listaUsuario = (WSDatosListaUsuarioTO)respuesta.getObject();
				WSUsuarioTO [] arregloUsuario = listaUsuario.getListaUsuario();
				System.out.println("[SECCD][UsuarioBO][listarUsuarios] arregloUsuario.length():<"+arregloUsuario.length+">");
				ArrayList	listaSalida = new ArrayList();
				for(int i=0;i<arregloUsuario.length;i++){
					listaSalida.add(arregloUsuario[i]);
				}
				System.out.println("[SECCD][UsuarioBO][listarUsuarios] listaUsuario.size():<"+listaSalida.size()+">");
				retSalida.setCode(0);
				retSalida.setObject(listaSalida);
			}else{
				retSalida.setCode(-1);
			}
		}catch(Exception e){
			retSalida = new BResult();
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
			retSalida.setMessage("[SECCD][UsuarioBO][buscarUsuarioxWebService] exception generado por:"+e.getMessage());
		}
		return retSalida;
	}
	
	/**
	 * Metodo que genera la respuesta a mostrar por el metodo valida usuario
	 * */
	public BResult validaCodigoRespuestaValidaUsuario(WSRespuestaUsuarioTO	respuesta){
		BResult retSalida = new BResult();
		String codigoRespuesta = respuesta.getCodigoRespuesta().toString();
		int getCode = Integer.valueOf(codigoRespuesta).intValue();
		WSUsuarioTO usuarioTO = null;
		try {
			if(getCode==0){
				retSalida.setCode(ConstantesSECCD.EXITO_RET);
				usuarioTO = respuesta.getDatos().getUsuarioTO();
				retSalida.setObject(usuarioTO);
			}else if(getCode==-2){
				retSalida.setCode(getCode);
				retSalida.setMessage(ConstantesMensajes.ERROR_CUENTA_NO_EXISTE);
			}else if(getCode==-3){
				//usuarioTO = respuesta.getDatos().getUsuarioTO();
				retSalida.setCode(getCode);
				retSalida.setMessage(ConstantesMensajes.ERROR_CONTRASENA);
				usuarioTO = respuesta.getDatos().getUsuarioTO();
				retSalida.setObject(usuarioTO);
				//retSalida.setObject(usuarioTO);
			}else if(getCode==-5){
				retSalida.setCode(getCode);
				retSalida.setMessage(ConstantesMensajes.ERROR_BLOQUEO_CUENTA_WS);
			}else if(getCode==-6){
				retSalida.setCode(getCode);
				retSalida.setMessage(ConstantesMensajes.ERROR_INACTIVA_CUENTA_WS);
			}else{
				retSalida.setCode(getCode);
				retSalida.setMessage(ConstantesMensajes.ERROR_AMBIENTE);
			}
		} catch (Exception e) {
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
			System.out.println("[SECCD][UsuarioBO][validaCodigoRespuestaValidaUsuario]:error generado por:"+e.getMessage());
		}
		return retSalida;
	}
	
	/**
	 * Metodo que registra un login fallido realizado por un usuario
	 * */
	public BResult registraLoginFallido(String strCodigoUsuario){
	
		BResult	retSalida  	= new BResult();
		int 	numIntentos = 0;
		try {
			BResult retConn = conectar();
			if(ConstantesSECCD.EXITO_RET==retConn.getCode() && retConn.getObject()!=null){
				UsuarioDAO	usuarioDAO   = new UsuarioDAO(conn);
				BResult retUsuario = usuarioDAO.obtieneUsuario(strCodigoUsuario);
				// si existe el usuario
				if(ConstantesSECCD.EXITO_RET==retUsuario.getCode()&& retUsuario.getObject()!=null){
					numIntentos = ((UsuarioTO)retUsuario.getObject()).getNumIntentos()+1;
					// se registra el login fallido
					BResult retRLF = usuarioDAO.registraLoginFallido(UtilTipoDato.convierteCadenaToInt(strCodigoUsuario.toString()),numIntentos);
					if(retRLF.getCode()==0){
						// si el numero de intentos es igual al tope de intentos
						if(ConstantesSECCD.NUM_INTENTOS_BLOQUEO==numIntentos){
							BResult retICU = usuarioDAO.inactivaCuentaUsuario(UtilTipoDato.convierteCadenaToInt(strCodigoUsuario));
							if(retICU.getCode()!=0){
								retSalida.setCode(ConstantesSECCD.ERROR_RET);
								System.out.println("[SECCD][UsuarioBO][registraLoginFallido]:"+ConstantesMensajesTrace.MSG_ERROR_INACTIVA_CUENTA);
							}
						}else if(ConstantesSECCD.NUM_INTENTOS_BLOQUEO<=numIntentos){
							System.out.println("[SECCD][UsuarioBO][registraLoginFallido]"+ConstantesMensajesTrace.MSG_ERROR_CUENTA_BLOQUEADA);
							retSalida.setCode(ConstantesSECCD.CODIGO_USUARIO_BLOQUEADO);
							retSalida.setMessage(ConstantesMensajes.ERROR_BLOQUEO_CUENTA);
						}
						retSalida.setMessage(retRLF.getMessage());
						System.out.println("[SECCD][UsuarioBO][retSalida.getMessage()]:"+retSalida.getMessage());
					}else{
						retSalida.setCode(ConstantesSECCD.ERROR_RET);
						System.out.println("[SECCD][UsuarioBO][registraLoginFallido]:"+ConstantesMensajesTrace.MSG_ERROR_REGISTRA_LOGIN_FALLIDO);
					}
				}else{
					retSalida.setCode(ConstantesSECCD.ERROR_RET);
					System.out.println("[SECCD][UsuarioBO][registraLoginFallido]:"+ConstantesMensajesTrace.MSG_ERROR_OBTIENE_GET_USUARIO);
				}
				// recuperando el numero de intentos fallidos
				if(numIntentos+1>=5){
					System.out.println("[SECCD][UsuarioBO][registraLoginFallido]: cuenta bloqueada!!!");
					retSalida.setCode(ConstantesSECCD.CODIGO_USUARIO_BLOQUEADO);
					retSalida.setMessage(ConstantesMensajes.ERROR_BLOQUEO_CUENTA);
				}
			}else{
				retSalida.setCode(ConstantesSECCD.ERROR_RET);
				System.out.println("[SECCD][UsuarioBO][registraLoginFallido]:"+ConstantesMensajesTrace.MSG_ERROR_OBTIENE_CONEXION_SECCD);
			}
		} catch (Exception e) {
			System.out.println("[SECCD][UsuarioBO][registraLoginFallido]:error generado por:"+e.getMessage());
			retSalida = new BResult();
			retSalida.setCode(ConstantesSECCD.ERROR_RET);
			retSalida.setMessage(e.getMessage());
		}
		return retSalida;
	}
	
	/**
	 * Metodo que realiza el match de los datos del usuario recuperados desde el web service y la base de datos del seccd
	 * */
	public UsuarioTO matchUsuarioTO(UsuarioTO entrada,BResult retWS,String password ){
			UsuarioTO 		salidaTO = new UsuarioTO();
			WSUsuarioTO 	usuarioWS 		=(WSUsuarioTO)(retWS.getObject());
			
			salidaTO = entrada;
			salidaTO.setApeMaterno(usuarioWS.getApeMaterno());
			salidaTO.setApePaterno(usuarioWS.getApePaterno());
			salidaTO.setNombre(usuarioWS.getNombre());
			salidaTO.setPassword_encriptada(password);
			
			salidaTO.setNombreCompleto(usuarioWS.getApePaterno()+" "+usuarioWS.getApeMaterno()+", "+usuarioWS.getNombre());
		return salidaTO;
	}
	
	/** 
	  * Metodo que realiza la validacion del usuario 
	  * */ 
	 public BResult validaUsuario(String username,String password) throws BusinessException{ 
		 BResult      	retSalida    		= new BResult(); 
		 BResult      	retUsuario   		= null; 
		 UsuarioDAO     usuarioDAO   		= null; 
		 BResult      	retWS    			= null; 
		 BResult      	retConn    			= new BResult(); 
		 int       		numIntentos   		= 0; 
		 String      	estadoCuentaSECCD 	= null; 
		 
		 try{ 
			   // se consume el metodo de validacion de usuario del webservice 
			   retWS = validaUsuarioxWebService(username, password); 
			    
			   // si el codigo de respuesta del web service es exito 
			   if(ConstantesSECCD.EXITO_RET==retWS.getCode() && retWS.getObject()!=null){ 
				   		retConn = conectar(); 
			     
				   		// si la conexion a la base de datos es exitosa 
				   		if(retConn.getCode()==0 && retConn.getObject()!=null){ 
				   			usuarioDAO   = new UsuarioDAO(conn); 
				   			// recuperando los datos del usuario desde base de datos de la tabla db2admin.usuario (numero de intentos y estado en el seccd) 
				   			retUsuario = usuarioDAO.obtieneUsuario(((WSUsuarioTO)(retWS.getObject())).getCodigo()); 
					     
				   			// si el username y password estan registrados 
				   			if(retUsuario.getCode()==0 && retUsuario.getObject()!=null){ 
					       
					    	 estadoCuentaSECCD = ((UsuarioTO)retUsuario.getObject()).getEstado();
					    	
					    	 // si la cuenta esta inactiva
					    	if(estadoCuentaSECCD.equalsIgnoreCase(ConstantesSECCD.ESTADO_INACTIVO)){
					    		// si el ultimo login se realizo hace menos de 30 minutos
							      if(((UsuarioTO)retUsuario.getObject()).getMinutosUltimoLogin()<30){
							    	  retSalida.setMessage(ConstantesMensajes.ERROR_ANTES_TIEMPO_DESBLOQUEO);
									  return retSalida;
							      }
							}
					    		
					    	if(((UsuarioTO)retUsuario.getObject()).getEstadoPerfil().equalsIgnoreCase("0")){
					    		retSalida.setMessage(ConstantesMensajes.ERROR_PERFIL_INACTIVO);
					    		return retSalida;
					    	}
					    	
					        UsuarioTO  usuarioTO   = (UsuarioTO)retUsuario.getObject(); 
					        usuarioTO = matchUsuarioTO(usuarioTO, retWS,password); 
					         
					        // recuperando el codigo de alumno en funcion a su codigo de usuario 
					        if(ConstantesSECCD.PERF_ALUMNO==usuarioTO.getPerfil()){ 
					        	usuarioTO.setCodigoAlumno(recuperaCodigoAlumno(usuarioTO)); 
					        } 
					    	 
					        // recuperando el codigo de medico en funcion a su codigo de usuario 
					        if(ConstantesSECCD.PERF_MEDDOC==usuarioTO.getPerfil()){ 
					        	usuarioTO.setCodigoMedicoDocente(recuperaCodigoMedicoDocente(usuarioTO)); 
					        }
					    	
					        OpcionDAO 	opcionDAO   = new OpcionDAO(conn); 
					        BResult 	retOpcion 	= opcionDAO.obtieneOpcionxPerfilUsuario(usuarioTO.getPerfil());
					        
					        if(retOpcion.getCode()==0 && retOpcion.getObject()!=null){ 
					        	ArrayList<OpcionTO> listaOpcion 	= (ArrayList<OpcionTO>)retOpcion.getObject(); 
					        	ModuloDAO 			moduloDAO    	= new ModuloDAO(conn); 
					        	BResult  			retModulo   	= moduloDAO.obtieneModuloxPerfilUsuario(usuarioTO.getPerfil()); 
					        	ArrayList 			listaModulo 	= (ArrayList<OpcionTO>)retModulo.getObject(); 
					        	BResult  			retResetea 		= usuarioDAO.reseteaNumIntentos(usuarioTO.getCodigo()); 
					        	if(retResetea.getCode()==0){ 
					           
					        		BResult  retActualizaFecha = usuarioDAO.actualizaFechaUltimoLogin(usuarioTO.getCodigo());  
					        		if(retResetea.getCode()==0){ 
					        			usuarioTO.setOpcion(listaOpcion); 
					        			usuarioTO.setModulo(listaModulo); 
					        			retSalida.setObject(usuarioTO); 
					        		}else{ 
					        			retSalida.setCode(ConstantesSECCD.ERROR_RET); 
					        			retSalida.setMessage(ConstantesMensajes.ERROR_ACTUALIZA_FECHA_LOGIN_CUENTA_SECCD); 
					        		} 
					        	}else{ 
					        		retSalida.setCode(ConstantesSECCD.ERROR_RET); 
					        		retSalida.setMessage(ConstantesMensajes.ERROR_BLOQUEO_CUENTA_SECCD); 
					        	} 
					        }else{ 
					        	retSalida.setCode(ConstantesSECCD.ERROR_RET); 
					        	retSalida.setMessage(ConstantesMensajes.ERROR_RESETEA_CUENTA_SECCD); 
					        } 
				     }
				    }else{  
				    	// error al obtener la conexion a la base de datos SECCD 
				    	retSalida.setCode(retConn.getCode()); 
				    	retSalida.setMessage(ConstantesMensajes.ERROR_AMBIENTE); 
				    } 
				   }else if(ConstantesSECCD.CODIGO_PASSWORD_INCORRECTO==retWS.getCode()){ 
					    retSalida.setCode(retWS.getCode()); 
					    retSalida.setMessage(retWS.getMessage()); 
					    String codigo = ((WSUsuarioTO)(retWS.getObject())).getCodigo(); 
					    BResult retRLF = registraLoginFallido(codigo); 
					    if(retRLF.getCode()!=0){ 
					     retSalida.setCode(ConstantesSECCD.ERROR_RET); 
					     retSalida.setMessage(retRLF.getMessage()); 
					    }else{ 
					     retSalida.setCode(retRLF.getCode()); 
					     retSalida.setMessage(retRLF.getMessage()); 
					    }     
				   } 
				   else if(ConstantesSECCD.CODIGO_USUARIO_BLOQUEADO==retWS.getCode()){ 
					    System.out.println("seccd:usuariobo:validaUsuario:entrando a CODIGO_USUARIO_BLOQUEADO"); 
					    retSalida.setCode(retWS.getCode()); 
					    retSalida.setMessage(retWS.getMessage()); 
				   } 
				   else if(ConstantesSECCD.CODIGO_USUARIO_INACTIVO==retWS.getCode()){ 
					    System.out.println("seccd:usuariobo:validaUsuario:entrando a CODIGO_USUARIO_INACTIVO"); 
					    retSalida  = new BResult(); 
					    retSalida.setMessage(retWS.getMessage()); 
				   } 
				   else if(ConstantesSECCD.CODIGO_USUARIO_NO_EXISTE==retWS.getCode()){ 
					    System.out.println("seccd:usuariobo:validaUsuario:entrando a CODIGO_USUARIO_NO_EXISTE"); 
					    retSalida  = new BResult(); 
					    retSalida.setMessage(retWS.getMessage()); 
				   } 
				   else{  
			   			// error al ejecutar el webservice 
			   			retSalida.setCode(retConn.getCode()); 
			   			retSalida.setMessage(ConstantesMensajes.ERROR_AMBIENTE); 
			   		}
			  }catch(Exception e){ 
				   retSalida.setCode(ConstantesSECCD.ERROR_RET); 
				   retSalida.setMessage(ConstantesMensajes.ERROR_AMBIENTE); 
				   System.out.println("[SECCD][UsuarioBO][validaUsuario]: error generado por:"+e.getMessage()); 
			  }finally{ 
				   try{ 
				    desconectar(); 
				   }catch(Exception e){ 
				    retSalida.setCode(ConstantesSECCD.ERROR_RET); 
				    retSalida.setMessage(e.getMessage()); 
				    System.out.println("[SECCD][UsuarioBO][validaUsuario]: error generado por:"+e.getMessage()); 
				   } 
			  } 
		  return retSalida; 
	 }

	 // recupera el codigo de medico docente          		
	 private String recuperaCodigoMedicoDocente(UsuarioTO usuarioTO){
		String				codigoMedico 	= null;			
     	MedicoDocenteBO 	meddocBO 		= new MedicoDocenteBO(); 
     	BResult      		retMedDoc 		= null;
     	try {
         	retMedDoc = meddocBO.getMedicoDocente(usuarioTO.getCodigo()); 
         	if(retMedDoc.getCode()==0){ 
         		codigoMedico = ((MedicoDocenteTO)retMedDoc.getObject()).getCodigo(); 
         	} 
		} catch (Exception e) {
			System.out.println("[SECCD][UsuarioBO][recuperaCodigoMedicoDocente]: error generado por:"+e.getMessage()); 
		}
     	return codigoMedico;
	 }
	 

	 // recupera el codigo de alumno          		
	 private String recuperaCodigoAlumno(UsuarioTO usuarioTO){
		String				codigoAlumno 	= null;
	 	AlumnoBO 			alumnoBO 		= new AlumnoBO(); 
     	BResult      		retAlumno 		= null;
     	try {
     	 	retAlumno = alumnoBO.getAlumno(usuarioTO.getCodigo()); 
         	if(retAlumno.getCode()==0){ 
         		codigoAlumno = ((AlumnoTO)retAlumno.getObject()).getCodigo();
         	} 
		} catch (Exception e) {
			System.out.println("[SECCD][UsuarioBO][recuperaCodigoAlumno]: error generado por:"+e.getMessage()); 
		}
     	return codigoAlumno;
	 }
}
